package billing

import (
	"fmt"
	"log"
	"net"
	"strings"
)

// ========================================
// 计费管理器 (Billing Manager)
// 统一管理拦截器链和付费页面生成
// 提供简单的API供QUIC服务器调用
// ========================================

// BillingManager 计费管理器
type BillingManager struct {
	chain                *InterceptorChain
	pageGenerator        *PaymentPageGenerator
	trafficInterceptor   *TrafficQuotaInterceptor
	bandwidthInterceptor *BandwidthLimitInterceptor
	enabled              bool // 全局开关
}

// NewBillingManager 创建计费管理器
func NewBillingManager() *BillingManager {
	// 创建拦截器
	trafficInterceptor := NewTrafficQuotaInterceptor(NewInMemoryQuotaStorage())
	bandwidthInterceptor := NewBandwidthLimitInterceptor(NewInMemoryBandwidthStorage())

	// 创建拦截器链
	chain := NewInterceptorChain()
	chain.AddInterceptor(trafficInterceptor)
	chain.AddInterceptor(bandwidthInterceptor)

	// 创建页面生成器
	pageGenerator := NewPaymentPageGenerator("Internal Net Bridge", "support@internalnetbridge.com")

	manager := &BillingManager{
		chain:                chain,
		pageGenerator:        pageGenerator,
		trafficInterceptor:   trafficInterceptor,
		bandwidthInterceptor: bandwidthInterceptor,
		enabled:              false, // 默认禁用，需要手动启用
	}

	log.Printf("💰 [计费] 计费管理器已初始化（默认禁用）")
	log.Printf("   ├─ 流量配额拦截器: 已加载")
	log.Printf("   ├─ 带宽限制拦截器: 已加载")
	log.Printf("   └─ 付费页面生成器: 已加载")

	return manager
}

// Enable 启用计费系统
func (m *BillingManager) Enable() {
	m.enabled = true
	log.Printf("✅ [计费] 计费系统已启用")
}

// Disable 禁用计费系统
func (m *BillingManager) Disable() {
	m.enabled = false
	log.Printf("⛔ [计费] 计费系统已禁用")
}

// IsEnabled 检查是否启用
func (m *BillingManager) IsEnabled() bool {
	return m.enabled
}

// CheckRequest 检查请求是否允许通过
// 🚀 这是核心方法，供QUIC服务器调用
// 返回：
//   - allowed: 是否允许通过
//   - response: 如果不允许，返回给客户端的响应数据（nil表示允许通过）
//   - err: 系统错误
func (m *BillingManager) CheckRequest(ctx *InterceptContext) (allowed bool, response []byte, err error) {
	// 如果全局禁用，直接放行
	if !m.enabled {
		return true, nil, nil
	}

	// 执行拦截器链
	result, err := m.chain.Execute(ctx)
	if err != nil {
		log.Printf("❌ [计费] 执行拦截器链失败: %v", err)
		return false, nil, err
	}

	// 检查结果
	if result.Available {
		// 允许通过
		return true, nil, nil
	}

	// 不允许通过，生成响应
	log.Printf("🚫 [计费] 请求被拦截: UserID=%s, TunnelID=%s, Reason=%s",
		ctx.UserID, ctx.TunnelID[:8]+"...", result.Reason)

	// 🔧 生成完整的HTTP响应（包含响应头和响应体）
	responseBody := m.pageGenerator.GenerateResponse(result, ctx)

	// 构建完整的HTTP响应（如果是HTTP协议）
	if ctx.Protocol == "HTTP" {
		// 判断Content-Type
		contentType := "text/html; charset=utf-8"
		if ctx.IsJSONRequest {
			contentType = "application/json; charset=utf-8"
		}

		// 构建完整HTTP响应
		httpResponse := fmt.Sprintf(
			"HTTP/1.1 402 Payment Required\r\n"+
				"Content-Type: %s\r\n"+
				"Content-Length: %d\r\n"+
				"Connection: close\r\n"+
				"X-Payment-Required: true\r\n"+
				"X-Order-ID: %s\r\n"+
				"\r\n"+
				"%s",
			contentType,
			len(responseBody),
			result.OrderID,
			string(responseBody),
		)
		return false, []byte(httpResponse), nil
	}

	// 非HTTP协议直接返回响应体
	return false, responseBody, nil
}

// SendPaymentRequired 发送付费要求响应
// 便捷方法，直接发送到net.Conn
func (m *BillingManager) SendPaymentRequired(conn net.Conn, ctx *InterceptContext) error {
	// 执行拦截器链获取结果
	result, err := m.chain.Execute(ctx)
	if err != nil {
		return err
	}

	// 如果允许通过，不发送
	if result.Available {
		return nil
	}

	// 发送付费页面
	return m.pageGenerator.SendToClient(conn, result, ctx)
}

// RecordResponseTraffic 记录响应流量
// 在请求完成后调用，记录响应大小
func (m *BillingManager) RecordResponseTraffic(userID string, responseSize int64) error {
	if !m.enabled {
		return nil
	}

	return m.trafficInterceptor.RecordResponseTraffic(userID, responseSize)
}

// SetUserQuota 设置用户流量配额（仅用于测试/演示）
func (m *BillingManager) SetUserQuota(userID string, totalQuotaGB int64, paymentType PaymentType, paymentURL, orderID string) {
	if storage, ok := m.trafficInterceptor.GetStorage().(*InMemoryQuotaStorage); ok {
		storage.SetQuota(userID, totalQuotaGB*1024*1024*1024, paymentType, paymentURL, orderID)
		log.Printf("💰 [计费] 设置用户流量配额: UserID=%s, Quota=%dGB", userID, totalQuotaGB)
	}
}

// SetUserBandwidth 设置用户带宽限制（仅用于测试/演示）
func (m *BillingManager) SetUserBandwidth(userID string, maxBandwidthMBps int64, paymentType PaymentType, paymentURL, orderID string) {
	if storage, ok := m.bandwidthInterceptor.GetStorage().(*InMemoryBandwidthStorage); ok {
		storage.SetPlan(userID, maxBandwidthMBps, paymentType, paymentURL, orderID)
		log.Printf("💰 [计费] 设置用户带宽限制: UserID=%s, Bandwidth=%dMB/s", userID, maxBandwidthMBps)
	}
}

// GetChain 获取拦截器链（用于添加自定义拦截器）
func (m *BillingManager) GetChain() *InterceptorChain {
	return m.chain
}

// GetPageGenerator 获取页面生成器（用于自定义品牌）
func (m *BillingManager) GetPageGenerator() *PaymentPageGenerator {
	return m.pageGenerator
}

// ========================================
// 便捷辅助函数
// ========================================

// ParseHTTPHeaders 解析HTTP头部（从字符串map转换）
func ParseHTTPHeaders(headers map[string][]string) map[string]string {
	result := make(map[string]string)
	for key, values := range headers {
		if len(values) > 0 {
			result[strings.ToLower(key)] = values[0]
		}
	}
	return result
}

// IsJSONRequest 判断是否是JSON请求
func IsJSONRequest(headers map[string]string) bool {
	contentType := strings.ToLower(headers["content-type"])
	return strings.Contains(contentType, "application/json")
}

// AcceptHTML 判断是否接受HTML响应
func AcceptHTML(headers map[string]string) bool {
	accept := strings.ToLower(headers["accept"])
	return accept == "" || strings.Contains(accept, "text/html") || strings.Contains(accept, "*/*")
}
